Implementing Loops and Iteration Techniques in Swift

Course: iOS App Development Training

Topic: Implementing Loops and Iteration Techniques

Course Link: iOS App Development Training at JustAcademy

Demo Link: Register for a Course Demo

JustAcademy Website: Visit JustAcademy

1. Introduction to Loops in Swift

Loops are programming structures that execute a block of code repeatedly while a specified condition is satisfied or for each element in a collection. In Swift, loops help developers automate repetitive tasks, process collections of data, perform calculations, and control repeated operations.

In iOS application development, loops are useful for displaying product lists, processing student marks, validating multiple records, generating reports, and working with data received from APIs.

For example, if an application needs to display the names of 100 users, a loop can process the user collection without requiring 100 separate print statements.

Why Are Loops Important?

• Code reusability: Execute the same instructions for multiple values.
• Reduced repetition: Avoid writing identical statements many times.
• Collection processing: Read and process arrays, dictionaries, and other sequences.
• Automation: Perform repetitive calculations and validation tasks.
• Improved readability: Express repetitive operations in a structured way.
• Efficient development: Simplify common tasks in application logic.

2. Understanding the Main Types of Loops in Swift

Swift provides several iteration techniques. The most commonly used loops are for-in, while, and repeat-while. Each has a different purpose depending on whether the number of iterations is known and when the loop condition must be checked.

3. Implementing the for-in Loop

The for-in loop is one of the most frequently used loops in Swift. It iterates over the elements of a sequence, such as an array, range, string, or dictionary.

3.1 Basic for-in Loop

A basic for-in loop assigns each element of a sequence to a temporary iteration variable and executes the loop body.

for number in 1...5 {
    print(number)
}

Output:

1
2
3
4
5

In this example, 1...5 is a closed range that includes both 1 and 5. The loop executes five times, printing one number during each iteration.

3.2 Using a Closed Range

A closed range uses three dots (...) and includes both its lower and upper bounds.

for index in 1...10 {
    print("Iteration: \(index)")
}

This loop executes ten times because the range includes every integer from 1 through 10.

3.3 Using a Half-Open Range

A half-open range uses two dots followed by a less-than symbol (..<). It includes the lower bound but excludes the upper bound.

for number in 0..<5 {
    print(number)
}

Output:

0
1
2
3
4

Half-open ranges are useful when working with array indexes because the last valid index of a non-empty array is one less than its count.

3.4 Using the Underscore Character

Use an underscore (_) when the iteration value is not needed. This makes the intention clear and avoids introducing an unused variable.

for _ in 1...3 {
    print("Welcome to Swift")
}

The message is printed three times. The loop performs a fixed number of repetitions without needing to use the range value.

4. Iterating Through Arrays

An array stores an ordered collection of values of the same element type. A for-in loop can process every element in an array without manually accessing each index.

Example: Displaying Product Names

let products = ["Laptop", "Mobile", "Tablet", "Headphones"]

for product in products {
    print("Product: \(product)")
}

This loop reads each product name and displays it. If a new product is added to the array, the loop can process it automatically without requiring another print statement.

Example: Calculating the Total of an Array

let prices = [100, 250, 150, 300]
var total = 0

for price in prices {
    total += price
}

print("Total: \(total)")

Output: Total: 800

The variable total accumulates each price. The operator += adds the current price to the existing total during every iteration.

5. Iterating Through Strings

Swift strings can be iterated over using a for-in loop. Each iteration produces a Character, allowing developers to inspect or process text one character at a time.

Example: Displaying Characters

let word = "Swift"

for character in word {
    print(character)
}

Output:

S
w
i
f
t

This technique is useful for text-processing exercises, character counting, and simple validation tasks. Remember that a Swift Character may contain multiple Unicode components, so character iteration does not necessarily mean processing individual bytes.

Example: Counting Characters

let message = "Hello Swift"
var characterCount = 0

for _ in message {
    characterCount += 1
}

print("Character count: \(characterCount)")

The result is 11 because the space between the two words is also counted as a character.

6. Iterating Through Dictionaries

A dictionary stores key-value pairs. Swift allows a for-in loop to process each pair using tuple destructuring.

Example: Displaying Student Details

let studentMarks = [
    "Aarav": 85,
    "Riya": 92,
    "Neha": 78
]

for (name, marks) in studentMarks {
    print("\(name): \(marks)")
}

The loop accesses the dictionary's keys and associated values. Dictionary iteration order is not guaranteed to match the order in which entries were written.

Example: Finding the Highest Mark

let marks = [85, 92, 78, 95, 88]
var highestMark = marks[0]

for mark in marks {
    if mark > highestMark {
        highestMark = mark
    }
}

print("Highest mark: \(highestMark)")

This example finds the largest mark by comparing every value with the current highest mark. It assumes the array contains at least one element; empty collections should be handled before accessing the first element.

7. Implementing the while Loop

The while loop repeats a block of code as long as its condition remains true. Swift checks the condition before each iteration, so the loop body may execute zero times if the condition is initially false.

Syntax

while condition {
    // Statements to execute
}

Example: Counting from 1 to 5

var number = 1

while number <= 5 {
    print(number)
    number += 1
}

Output:

1
2
3
4
5

The loop begins with number equal to 1. It prints the current value and increments it. Once the value becomes 6, the condition evaluates to false and the loop terminates.

When Should You Use a while Loop?

• When the number of iterations is not known in advance.
• When execution depends on a condition that changes over time.
• When processing data until a stopping condition is reached.
• When repeating an operation while a state remains valid.

8. Implementing the repeat-while Loop

The repeat-while loop is similar to a while loop, but the condition is checked after the loop body executes. Therefore, the body always executes at least once.

Syntax

repeat {
    // Statements to execute
} while condition

Example: Counting from 1 to 5

var number = 1

repeat {
    print(number)
    number += 1
} while number <= 5

Output:

1
2
3
4
5

Difference Between while and repeat-while

var firstNumber = 10

while firstNumber < 5 {
    print("While loop")
}

var secondNumber = 10

repeat {
    print("Repeat-while loop")
} while secondNumber < 5

The while loop prints nothing because its condition is initially false. The repeat-while loop prints its message once because it checks the condition only after executing the body.

9. Controlling Loop Execution with break

The break statement immediately terminates the nearest enclosing loop. It is useful when the required result has been found or continuing the loop is no longer necessary.

Example: Stop at a Specific Number

for number in 1...10 {
    if number == 6 {
        break
    }

    print(number)
}

Output:

1
2
3
4
5

When the value becomes 6, the break statement terminates the loop before 6 is printed.

Example: Searching an Array

let numbers = [12, 25, 37, 49, 60]
let target = 37
var found = false

for number in numbers {
    if number == target {
        found = true
        break
    }
}

print("Found: \(found)")

Once the target is found, there is no need to inspect the remaining elements. The loop stops and the program reports the result.

10. Skipping Iterations with continue

The continue statement skips the remaining statements in the current iteration and proceeds to the next iteration of the loop.

Example: Skipping the Number 3

for number in 1...5 {
    if number == 3 {
        continue
    }

    print(number)
}

Output:

1
2
4
5

Example: Printing Only Odd Numbers

for number in 1...10 {
    if number % 2 == 0 {
        continue
    }

    print(number)
}

The remainder operator % checks whether a number is divisible by 2. Even numbers are skipped, leaving only odd numbers in the output.

11. Nested Loops in Swift

A nested loop is a loop placed inside another loop. Nested loops are useful for working with two-dimensional arrays, tables, coordinate grids, schedules, and combinations of values.

Example: Multiplication Table

for row in 1...3 {
    for column in 1...3 {
        print("\(row) x \(column) = \(row * column)")
    }
}

The outer loop controls the row value, while the inner loop runs through the column values for each row. The inner loop completes all its iterations before the outer loop moves to its next iteration.

Example: Printing a Pattern

for row in 1...4 {
    for _ in 1...row {
        print("*", terminator: "")
    }

    print()
}

Output:

*
**
***
****

The number of stars printed on each line depends on the current row number. The terminator: "" argument prevents each star from being printed on a separate line.

Important Considerations

• Nested loops may execute many times when both ranges are large.
• Keep loop bodies focused and readable.
• Avoid unnecessary nested loops when a simpler collection operation is sufficient.
• Use meaningful variable names such as row and column.

12. Iterating with enumerated()

The enumerated() method allows developers to iterate through a sequence while obtaining both an offset and the corresponding element. It is useful when displaying numbered lists or processing items alongside their positions.

Example: Numbering a List of Tasks

let tasks = [
    "Learn Swift",
    "Practice loops",
    "Build an iOS app"
]

for (index, task) in tasks.enumerated() {
    print("\(index + 1). \(task)")
}

Output:

1. Learn Swift
2. Practice loops
3. Build an iOS app

The enumerated offset starts at zero, so adding one creates a user-friendly numbered list. For collections with custom indexes, the enumerated offset should not be assumed to be the collection's actual index.

13. Iterating with stride()

The stride() function creates a sequence that advances by a specified step. It is useful when a loop needs to skip values or count backward.

13.1 Counting in Steps

for number in stride(from: 0, through: 10, by: 2) {
    print(number)
}

Output:

0
2
4
6
8
10

The through: form includes the endpoint when the sequence reaches it.

13.2 Counting Backward

for number in stride(from: 5, through: 1, by: -1) {
    print(number)
}

Output:

5
4
3
2
1

13.3 Excluding the Endpoint

for number in stride(from: 0, to: 10, by: 3) {
    print(number)
}

Output:

0
3
6
9

The to: form excludes the endpoint. Choose a positive or negative step that moves toward the endpoint; otherwise, the generated sequence may be empty.

14. Using Loops with Conditions

Loops can contain conditional statements to make decisions for each item. This is useful when some values require special handling.

Example: Categorizing Marks

let marks = [45, 78, 32, 90, 66]

for mark in marks {
    if mark >= 75 {
        print("\(mark): Distinction")
    } else if mark >= 40 {
        print("\(mark): Pass")
    } else {
        print("\(mark): Needs improvement")
    }
}

Each mark is evaluated independently. The program classifies it using the first matching condition.

Example: Calculating the Sum of Even Numbers

let numbers = [10, 15, 20, 25, 30]
var sum = 0

for number in numbers {
    if number % 2 == 0 {
        sum += number
    }
}

print("Sum of even numbers: \(sum)")

Output: Sum of even numbers: 60

15. Looping Through Two-Dimensional Arrays

A two-dimensional array stores arrays inside another array. It can represent tables, grids, seating arrangements, or rows of application data.

Example: Displaying a Matrix

let matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix {
    for value in row {
        print(value, terminator: " ")
    }

    print()
}

Output:

1 2 3
4 5 6
7 8 9

The outer loop visits each row, while the inner loop processes the values within that row.

16. Looping Techniques in SwiftUI

In SwiftUI, the ForEach view is commonly used to create repeated interface elements from a collection of data. It is a declarative UI construct rather than a traditional imperative loop.

Example: Displaying a List of Names

import SwiftUI

struct ContentView: View {
    let names = ["Aarav", "Riya", "Neha", "Kabir"]

    var body: some View {
        List {
            ForEach(names, id: \.self) { name in
                Text(name)
            }
        }
    }
}

This code creates a list row for each name. The id: \.self approach is suitable here because the strings are unique. For application models, prefer stable unique identifiers when available.

Example: Displaying Numbered Rows

import SwiftUI

struct ContentView: View {
    let tasks = [
        "Learn Swift",
        "Build an interface",
        "Test the application"
    ]

    var body: some View {
        List {
            ForEach(
                Array(tasks.enumerated()),
                id: \.offset
            ) { index, task in
                Text("\(index + 1). \(task)")
            }
        }
    }
}

This example creates a numbered list using each element's enumerated offset. If the collection changes frequently, ensure the chosen identifiers remain appropriate for the data and UI updates.

for-in Versus ForEach

17. Common Loop Errors and How to Avoid Them

18. Best Practices for Implementing Loops

• Use for-in when iterating over collections or known ranges.
• Use while when repetition depends on a condition checked before execution.
• Use repeat-while when the body must execute at least once.
• Ensure that condition-controlled loops can eventually terminate.
• Use break when the required result has been found.
• Use continue to skip items that do not require processing.
• Prefer direct element iteration when array indexes are unnecessary.
• Use meaningful variable names that explain the purpose of each iteration.
• Avoid unnecessary nested loops for large datasets.
• Check whether collections can be empty before accessing their elements.
• Use SwiftUI ForEach with suitable identity values when generating repeated views.
• Test boundary conditions, including empty collections and the first and last elements.

19. Hands-On Practice Exercises

Exercise 1: Print Numbers

Write a program that prints all integers from 1 through 20 using a for-in loop.

Learning objective: Practice closed ranges.

Exercise 2: Print Even Numbers

Print all even numbers between 1 and 50 using a loop and the remainder operator.

Learning objective: Combine loops with conditional statements.

Exercise 3: Calculate an Average

Given an array of student marks, calculate the total and average using a loop.

Learning objective: Accumulate values and process collections.

Exercise 4: Reverse Counting

Use stride() to print numbers from 10 down to 1.

Learning objective: Iterate backward with a negative step.

Exercise 5: Search for an Item

Search an array for a specified product name. Use break to stop once the product is found.

Learning objective: Implement a basic search algorithm.

Exercise 6: Generate a Pattern

Use nested loops to print a triangle of stars with five rows.

Learning objective: Understand nested iteration and output formatting.

20. Mini Project: Student Marks Analysis

Project Objective: Build a Swift program that processes a list of student marks, calculates the total and average, counts passing students, and identifies the highest mark.

Project Requirements

• Store marks in an integer array.
• Calculate the sum of all marks.
• Calculate the average.
• Count marks greater than or equal to 40.
• Identify the highest mark.
• Display the final results clearly.
• Handle an empty array safely.

Example Implementation

let marks = [85, 42, 67, 91, 35, 76]

if !marks.isEmpty {
    var total = 0
    var passCount = 0
    var highest = marks[0]

    for mark in marks {
        total += mark

        if mark >= 40 {
            passCount += 1
        }

        if mark > highest {
            highest = mark
        }
    }

    let average = Double(total) / Double(marks.count)

    print("Total Marks: \(total)")
    print("Average Marks: \(average)")
    print("Passing Students: \(passCount)")
    print("Highest Mark: \(highest)")
} else {
    print("No marks available.")
}

Expected Results

• Total marks: 396
• Average marks: 66.0
• Passing marks count: 5
• Highest mark: 91

This project combines array iteration, accumulation, conditional statements, numeric conversion, and safe handling of empty collections.

21. Interview Questions and Answers

Q1. What is a loop in Swift?

A loop is a control-flow structure that repeatedly executes code over a sequence or while a condition is satisfied.

Q2. What are the main types of loops in Swift?

The main loop structures are for-in, while, and repeat-while.

Q3. What is the difference between a closed range and a half-open range?

A closed range, such as 1...5, includes both endpoints. A half-open range, such as 1..<5, includes the lower endpoint but excludes the upper endpoint.

Q4. What is the difference between while and repeat-while?

A while loop checks its condition before executing the body. A repeat-while loop executes its body first and checks the condition afterward.

Q5. What is an infinite loop?

An infinite loop is a loop that does not terminate because its stopping condition is never reached or never becomes false.

Q6. What is the purpose of break?

The break statement immediately exits the nearest enclosing loop.

Q7. What is the purpose of continue?

The continue statement skips the remaining statements in the current iteration and proceeds to the next iteration.

Q8. What is a nested loop?

A nested loop is a loop inside another loop. It is commonly used to process grids, matrices, and combinations of values.

Q9. How does enumerated() work?

The enumerated() method produces pairs containing an offset and an element, allowing a loop to access both values.

Q10. What is stride() used for?

stride() creates a sequence that advances by a specified step, enabling forward or backward iteration.

Q11. How do you iterate over an array in Swift?

Use a for-in loop to access each element directly, or use indexes when the position is specifically required.

Q12. What is SwiftUI ForEach?

ForEach is a SwiftUI construct that creates repeated views from a collection of identifiable data.

Q13. Why should loops be tested with empty collections?

Empty collections can expose assumptions about available elements, especially when code accesses the first element or divides by the collection's count.

Q14. How can nested loops affect performance?

Nested loops may perform many more iterations than a single loop. For two loops that each process n elements, the total work can grow proportionally to n squared.

Q15. When should you use a for-in loop instead of while?

Use for-in when processing a sequence or range. Use while when the number of iterations depends on a condition that changes during execution.

22. Quick Revision Checklist

• Understand the purpose of loops and iteration.
• Implement for-in, while, and repeat-while.
• Understand closed and half-open ranges.
• Iterate through arrays, strings, and dictionaries.
• Use break and continue appropriately.
• Work with nested loops and two-dimensional arrays.
• Use enumerated() to obtain offsets and elements.
• Use stride() for stepped and backward iteration.
• Understand SwiftUI ForEach and view identity.
• Avoid infinite loops and array index errors.
• Test empty collections and boundary conditions.
• Complete the Student Marks Analysis mini project.

23. Conclusion

Implementing loops and iteration techniques is an essential skill for Swift and iOS application development. Loops simplify repetitive tasks, make collection processing easier, and support the implementation of common algorithms. By mastering for-in, while, repeat-while, nested loops, break, continue, enumerated(), and stride(), developers can write more readable and maintainable code.

In SwiftUI, understanding iteration also helps developers generate repeated interface elements with ForEach and stable identities. Regular practice with arrays, calculations, searches, and UI lists will strengthen your ability to build reliable native iOS applications.

Continue learning with JustAcademy: Explore the iOS App Development Training Course, register for a course demo, or visit the JustAcademy official website.